home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / PRGMANIA / QEDSRC / PRINTER.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-14  |  22.4 KB  |  956 lines
  1. #include "global.h"
  2. #include "block.h"
  3. #include "desktop.h"
  4. #include "event.h"
  5. #include "fontsel.h"
  6. #include "icon.h"
  7. #include "obj.h"
  8. #include "rsc.h"
  9. #include "set.h"
  10. #include "text.h"
  11. #include "windows.h"
  12. #include "wp-print.h"
  13. #include "printer.h"
  14.  
  15. /*
  16.  * Exportierte Variablen
  17.  */
  18. WORD            iprinter, printer_type;
  19. WORD            rand_len;
  20. BOOLEAN        zeilen_nr, seiten_nr, vorschub, pruef_prn, use_gdos_print,
  21.                 use_rand, print_block;
  22. WORD            gdos_device;
  23. WORD            wp_mode, wp_seiten_len, wp_seiten_width;
  24. PATH            wp_treiber, metafile;
  25. BOOLEAN        wp_nlq, prn_ok;
  26.  
  27. /****** DEFINES **************************************************************/
  28.  
  29. /****** TYPES ****************************************************************/
  30.  
  31. typedef struct{
  32.     WORD    devID;                        /* die Nummer (21 .. 99) */
  33.     UBYTE    devName[DEV_LEN - 1];    /* der Name */
  34.     WORD    FntAnz;                        /* die Anzahl der Fonts */
  35.     UBYTE    firstName[32];                /* name des ersten Fonts */
  36.     WORD    firstID;                        /* ID des ersten Fonts */
  37.     WORD    firstSize;                    /* Grö₧e des ersten Fonts */
  38. } DevInfoS;
  39.  
  40. /****** VARIABLES ************************************************************/
  41.  
  42. LOCAL WORD            xpos, prn_x, prn_y, prn_w, prn_h, line_height;
  43. LOCAL WORD            prn_handle,     /* GDOS */
  44.                         prn_device;        /* GEMDOS */
  45. LOCAL BOOLEAN        dev_has_changed;
  46. LOCAL DevInfoS        GdosDevices[10];
  47. LOCAL WORD            dev_anzahl;
  48.  
  49. /****** FUNCTIONS ************************************************************/
  50.  
  51. LOCAL VOID        plot_char    (UBYTE c);
  52. LOCAL VOID        plot_str        (UBYTE *adr, WORD rand, BOOLEAN tab, WORD tab_size);
  53. LOCAL VOID        plot_int        (WORD z, WORD stellen);
  54.  
  55. LOCAL VOID        icon_exist    (WORD icon, SET actions);
  56. LOCAL BOOLEAN    icon_test    (WORD icon, WORD action);
  57. LOCAL WORD        icon_edit    (WORD icon, WORD action);
  58. LOCAL BOOLEAN    icon_drag    (WORD icon, WORD source);
  59. LOCAL VOID        drucken        (UBYTE *name, RINGP t, BOOLEAN tab, WORD tab_size);
  60. LOCAL VOID        gdos_drucken(UBYTE *name, RINGP t, BOOLEAN tab, WORD tab_size);
  61. LOCAL BOOLEAN    prn_check     (WORD wait_time);
  62.  
  63. /***************************************************************************/
  64.  
  65. short MicromToDPI( short microm)
  66. {
  67.     switch (microm)
  68.     {
  69.         case 35:            return 720;
  70.         case 42:            return 600;
  71.         case 71:            return 360;
  72.         case 85:            return 300;
  73.         case 117:
  74.         case 118:        return 216;
  75.         case 130:        return 196;
  76.         case 141:        return 180;
  77.         case 175:
  78.         case 176:        return 144;
  79.         case 211:
  80.         case 212:        return 120;
  81.         default:            return 25400 / microm;
  82.     }
  83. } /* MicromToDPI */
  84.  
  85.  
  86. BOOLEAN    DeviceInfo(WORD devID, DevInfoS *devInfo)
  87. {
  88.     WORD    workin[] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2};
  89.     WORD    workout[57];
  90.     WORD    wkHandle;
  91.     WORD    devExist;
  92.     WORD    i, id;
  93.     UBYTE    name[80];
  94.  
  95.     if (!vq_gdos())
  96.             return FALSE;
  97.  
  98.     workin[0] = devID;
  99.     wkHandle = -1;
  100.     v_opnwk( workin, &wkHandle, workout);
  101.     if (wkHandle <= 0)
  102.         return FALSE;
  103.  
  104.     devInfo->devID   = devID;
  105.     devInfo->FntAnz  = workout[10] + vst_load_fonts(wkHandle, 0);
  106.  
  107.     if (devInfo->FntAnz <= 0)    /* Treiber nur gültig, wenn es auch Fonts gibt!! */
  108.     {
  109.         vst_unload_fonts(wkHandle, 0);
  110.         v_clswk( wkHandle);
  111.         return FALSE;
  112.     }
  113.  
  114.     for (i=1; i<100; i++)
  115.     {
  116.         id = vqt_name(wkHandle, i, devInfo->firstName);
  117.         if (id >= 0)
  118.             break;
  119.     }
  120.     if (id < 0)
  121.         return FALSE;
  122.  
  123.     devInfo->firstSize = vst_point(wkHandle, 10, &i, &i, &i, &i);
  124.     devInfo->firstID    = id;
  125.  
  126.     _VDIParBlk.contrl[2] = 0;
  127.     vqt_devinfo( wkHandle, devID, &devExist, name);
  128.     if (_VDIParBlk.contrl[2] == 0)            /*** Funktion ist nicht implementiert, generiere Namen ***/
  129.     {
  130.         if ((devID >= 21) && (devID < 31))
  131.             sprintf(name, "GDOS PRINTER %d", devID);
  132.         else if ((devID >= 31) && (devID < 41))
  133.             sprintf(name, "GDOS METAFILE %d", devID);
  134.         else
  135.             sprintf(name, "GDOS DEVICE %d", devID);
  136.     }
  137.     else if (_VDIParBlk.contrl[2] == 1)
  138.     {
  139.         /*** Nur Dateiname des Geraetetreibers vorhanden ***/
  140.         i = _VDIParBlk.contrl[4];
  141.         if (i > 11)
  142.             i = 11;
  143.         name[i] = 0;
  144.     }
  145.     else /* if (_VDIParBlk.contrl[2] == 14) */
  146.     {
  147.         WORD    p = 0;
  148.         UBYTE    *s;
  149.  
  150.         /*** Treiberbezeichnung ***/
  151.         s = (UBYTE *)&_VDIParBlk.ptsout[1];
  152.         for (i = 0; (i < 40) && (*s); i++)
  153.             name[p++] = *s++;
  154.         name[p] = EOS;
  155.     }
  156.     vst_unload_fonts(wkHandle, 0);
  157.     v_clswk( wkHandle);
  158.  
  159.     strncpy(devInfo->devName, name, DEV_LEN - 1);
  160.     devInfo->devName[DEV_LEN - 1] = EOS;
  161.  
  162.     return( TRUE);
  163. } /* DeviceInfo */
  164.  
  165.  
  166. VOID    scanDevices(VOID)
  167. {
  168.     WORD    i;
  169.  
  170.     if (dev_anzahl != 0)    /* nur einmal scannen! */
  171.         return;
  172.     start_aktion(STRING(SEARCHGDOS), FALSE, 80);
  173.     dev_anzahl = 0;
  174.     for (i = 21; i < 100; i++)
  175.     {
  176.         do_aktion(i - 20);
  177.         if (DeviceInfo(i, &GdosDevices[dev_anzahl]))
  178.             dev_anzahl++;
  179.     }
  180.     if (file_exist("gemfile.gem"))    /* Metafile-Treiber legt eine leere Datei an */
  181.         Fdelete("gemfile.gem");            /* die wir nun wieder löschen. */
  182.     end_aktion();
  183. }
  184.  
  185.  
  186. /***************************************************************************/
  187.  
  188. LOCAL VOID icon_exist(WORD icon, SET actions)
  189. {
  190.     setclr(actions);
  191.     setincl(actions,DO_INIT);
  192.     setincl(actions,DO_HELP);
  193. }
  194.  
  195. LOCAL BOOLEAN icon_test(WORD icon, WORD action)
  196. {
  197.     BOOLEAN    erg;
  198.  
  199.     switch(action)
  200.     {
  201.         case DO_INIT :    erg = TRUE;    break;
  202.         case DO_HELP :    erg = TRUE;    break;
  203.         default         :    erg = FALSE;
  204.     }
  205.     return erg;
  206. }
  207.  
  208. /***************************************************************************/
  209. /* Operation durchführen                                                                    */
  210. /***************************************************************************/
  211.  
  212. LOCAL WORD    icon_edit(WORD icon, WORD action)
  213. {
  214.     switch(action)
  215.     {
  216.         case DO_INIT    :    show_icon(icon); break;
  217.         case DO_HELP    :    note (1, HELPPRIN); break;
  218.     }
  219.     return 1;
  220. }
  221. /***************************************************************************/
  222. /* Auf den Drucker wurde ein Icon gezogen                                                */
  223. /***************************************************************************/
  224.  
  225. LOCAL BOOLEAN icon_drag (WORD icon, WORD source)
  226. {
  227.     return (do_icon(source,DO_PRINT)>0);
  228. }
  229.  
  230. /*****************************************************************************/
  231. /* Drucker-TestRoutinen                                                                                                            */
  232. /*****************************************************************************/
  233.  
  234. LOCAL BOOLEAN prn_ready (VOID)
  235. {
  236.     switch (prn_device)
  237.     {
  238.         case 0 :
  239.             return Cprnos() != 0;
  240.         case 1 :
  241.             return Cauxos() != 0;
  242.         default:
  243.             return FALSE;
  244.     }
  245. } /* prn_ready */
  246.  
  247.  
  248. LOCAL BOOLEAN prn_check (WORD wait_time)
  249. {
  250.     BOOLEAN    ok = FALSE,
  251.                 cancel = FALSE;
  252.     LONG        timer;
  253.  
  254.     /* Schnittstelle nur bei Druckertreibern überprüfen!! */
  255.     if ((pruef_prn && !use_gdos_print) ||
  256.          (pruef_prn && use_gdos_print && (GdosDevices[gdos_device].devID >= 21 && GdosDevices[gdos_device].devID <= 30)))
  257.     {
  258.         while (!ok && !cancel)
  259.         {
  260.             timer = 200 * wait_time + clock();
  261.             ok = prn_ready();
  262.             while (!ok && (timer > clock()))
  263.                 ok = prn_ready();
  264.             if (!ok)
  265.                  cancel = (note(1, PRNOTRDY) == 2);
  266.         }
  267.         return (ok && !cancel);
  268.     }
  269.     else
  270.         return TRUE;
  271. } /* prn_check */
  272.  
  273. /***************************************************************************/
  274.  
  275. LOCAL VOID plot_char(UBYTE c)
  276. {
  277.     UBYTE    str[2];
  278.     WORD    ext[8];
  279.  
  280.     if (use_gdos_print)
  281.     {
  282.         str[0] = c;
  283.         str[1] = EOS;
  284.         v_gtext(prn_handle,prn_x,prn_y,str);
  285.         vqt_extent(prn_handle,str,ext);
  286.         prn_x += (ext[2] - ext[0]);
  287.     }
  288.     else
  289.     {
  290.         if (c=='\n' || c=='\r')
  291.             xpos = 0;
  292.         else if (xpos >= wp_seiten_width)
  293.             return;
  294.         else xpos++;
  295.         WPWrite(c);
  296.     }
  297. }
  298.  
  299. LOCAL VOID plot_ff(VOID)
  300. {
  301.     if (use_gdos_print)
  302.     {
  303.         prn_x = 0;
  304.         prn_y = 0;
  305.         v_updwk(prn_handle);
  306.         v_clrwk(prn_handle);
  307.     }
  308.     else
  309.         WPFormFeed();
  310. }
  311.  
  312. LOCAL VOID plot_nl(VOID)
  313. {
  314.     if (use_gdos_print)
  315.     {
  316.         prn_x = 0;
  317.         prn_y += line_height;
  318.     }
  319.     else
  320.     {
  321.         xpos = 0;
  322.         WPWriteLn();
  323.     }
  324. }
  325.  
  326. LOCAL VOID plot_str(UBYTE *adr, WORD rand, BOOLEAN tab, WORD tab_size)
  327. {
  328.     WORD         tabH;
  329.  
  330.     while    ((--rand)>=0)
  331.         plot_char(' ');
  332.     tabH = 0;
  333.     while    (*adr!='\0')
  334.     {
  335.         if (!tabH)
  336.             tabH = tab_size;
  337.         if (tab && *adr == '\t')
  338.         {
  339.             while (tabH > 0)
  340.             {
  341.                 plot_char(' ');
  342.                 tabH--;
  343.             }
  344.             tabH = tab_size;
  345.         }
  346.         else
  347.         {
  348.             plot_char(*adr);
  349.             tabH --;
  350.         }
  351.         adr++;
  352.     }
  353. }
  354.  
  355. LOCAL VOID plot_int(WORD z, WORD stellen)
  356. {
  357.     UBYTE str[12];
  358.  
  359.     itoa(z,str,10);
  360.     plot_str(str, stellen - (short)strlen(str), FALSE, 0);
  361. }
  362.  
  363. VOID blk_drucken(UBYTE *name, TEXTP t_ptr)
  364. {
  365.     RING t;
  366.  
  367.     block_copy(t_ptr,&t);
  368.     if (use_gdos_print)
  369.         gdos_drucken(name, &t, t_ptr->loc_opt->tab, t_ptr->loc_opt->tabsize);
  370.     else
  371.         drucken(name, &t, t_ptr->loc_opt->tab, t_ptr->loc_opt->tabsize);
  372.     kill_textring(&t);
  373. }
  374.  
  375. VOID txt_drucken(UBYTE *name, TEXTP t_ptr)
  376. {
  377.     if (use_gdos_print)
  378.         gdos_drucken(name, &t_ptr->text, t_ptr->loc_opt->tab, t_ptr->loc_opt->tabsize);
  379.     else
  380.         drucken(name, &t_ptr->text, t_ptr->loc_opt->tab, t_ptr->loc_opt->tabsize);
  381. }
  382.  
  383. LOCAL BOOLEAN open_printer(VOID)
  384. {
  385.     WORD    work_in[11], work_out[57];
  386.     WORD    i, p_xy[4], dummy;
  387.  
  388.     if (gdos_device < 0)
  389.         return FALSE;
  390.  
  391.     for (i=0; i<=10; i++)
  392.         work_in[i] = 1;
  393.     work_in[0] = GdosDevices[gdos_device].devID;                    /* Drucker */
  394.     work_in[5] = 0;
  395.     work_in[10] = RC;
  396.     v_opnwk(work_in, &prn_handle, work_out);
  397.  
  398.     /* Pfad für eventuelle Dateiausgabe setzen */
  399.     if ((metafile[0] != EOS) && (GdosDevices[gdos_device].devID >= 31))
  400.     {
  401.         PATH    tmp;
  402.  
  403.         vm_filename(prn_handle, metafile);
  404.         file_splitt(metafile, tmp, NULL);
  405.         set_path(tmp);
  406.     }
  407.  
  408.     if (prn_handle==0)
  409.         return FALSE;
  410.     prn_w = work_out[0];
  411.     prn_h = work_out[1];
  412.     p_xy[0] = 0;
  413.     p_xy[1] = 0;
  414.     p_xy[2] = prn_w-1;
  415.     p_xy[3] = prn_h+1;
  416.     vs_clip(prn_handle, TRUE, p_xy);
  417.     vq_extnd (prn_handle, FALSE, work_out);    /* So, wg. Fehler im VDI */
  418.     druckFont.Anz = work_out[10];
  419.     druckFont.Anz += vst_load_fonts(prn_handle,0);
  420.     if (druckFont.Anz == 0)
  421.         return FALSE;
  422.     if (druckFont.ID == 0 || druckFont.Index == 0)
  423.     {
  424.         for (i = 1; i < 100; i++)
  425.         {
  426.             if (druckFont.ID == vqt_name(prn_handle, i, druckFont.Name))
  427.             {
  428.                 druckFont.Index = i;
  429.                 break;
  430.             }
  431.         }
  432.         if (druckFont.Index < 0)
  433.             return FALSE;
  434.         vst_font (prn_handle, druckFont.ID);
  435.         druckFont.Size = vst_point(prn_handle, druckFont.Size, &dummy, &dummy, &dummy, &dummy);
  436.     }
  437.  
  438.     vswr_mode(prn_handle, MD_TRANS);
  439.     return TRUE;
  440. }
  441.  
  442. LOCAL VOID close_printer(VOID)
  443. {
  444.     vst_unload_fonts(prn_handle,0);
  445.     v_clswk(prn_handle);
  446. }
  447.  
  448. LOCAL VOID gdos_drucken(UBYTE *name, RINGP t, BOOLEAN tab, WORD tab_size)
  449. {
  450.     WORD        p_xy[8], dummy, eff[3], seite, lzeile, gdos_seiten_len;
  451.     UBYTE        datum[11], str[40];
  452.     long        zeile;
  453.     LINEP        lauf;
  454.  
  455.     if (!open_printer())
  456.         return;
  457.  
  458.     if (!prn_check(0))
  459.     {
  460.         close_printer();
  461.         return;
  462.     }
  463.  
  464.     /* Einige Einstellungen für Metafile */
  465.     if (GdosDevices[gdos_device].devID >= 31 && GdosDevices[gdos_device].devID <= 40)
  466.     {
  467.         vm_pagesize(prn_handle, 2100, 2970);            /* Blattgrö₧e DIN A4 */
  468. /*        vm_coords(prn_handle, 0, 0, 2480, 3508);*/
  469.         vm_coords(prn_handle, 0, 2480, 3508, 0);
  470.         v_meta_extents(prn_handle, 0, 0, 2480, 3508);
  471.     }
  472.  
  473.     vst_font(prn_handle, druckFont.ID);
  474.     vst_point(prn_handle, druckFont.Size, &dummy, &dummy, &dummy, &dummy);
  475.  
  476.     vqt_fontinfo(prn_handle, &dummy, &dummy, p_xy, &dummy, eff);
  477.     line_height = p_xy[0] + p_xy[4] + 1;
  478.     vst_alignment(prn_handle, TA_LEFT , TA_ASCENT, &dummy, &dummy); /* Oberkante */
  479.     vqt_extent(prn_handle,"Hallo",p_xy);
  480.     prn_x = 0; prn_y = 0;
  481.  
  482.     get_datum(datum);
  483.     gdos_seiten_len = prn_h/line_height;
  484.     lzeile = gdos_seiten_len;
  485.     seite = 1;
  486.     zeile = 0;
  487.  
  488.     strcpy(str, STRING(PRINTSTR));
  489.     strcat(str,name);
  490.     start_aktion(str,TRUE,t->lines);
  491.  
  492.     Busy_mouse();
  493.     lauf = FIRST(t);
  494.     while (TRUE)
  495.     {
  496.         if (!prn_check(5))
  497.             break;
  498.  
  499.         if (abbruch())
  500.             if (note(1,BREAK)==1) break;
  501.  
  502.         if (lzeile == gdos_seiten_len)
  503.         {
  504.             lzeile = 0;
  505.             if (zeile!=0) plot_ff();
  506.             if (seiten_nr)
  507.             {
  508.                 plot_str(STRING(FILESTR), 7, FALSE, 0);
  509.                 plot_str(name,1,FALSE,0);
  510.                 plot_str(STRING(PAGESTR), 8, FALSE, 0);
  511.                 plot_int(seite++,0);
  512.                 plot_str(STRING(DATESTR), 8, FALSE, 0);
  513.                 plot_str(datum,0,FALSE,0);
  514.                 plot_nl();
  515.                 plot_nl();
  516.                 lzeile = 2;
  517.             }
  518.         }
  519.         do_aktion(zeile);
  520.         zeile++;
  521.         lzeile++;
  522.         if (use_rand && rand_len > 0)
  523.             plot_str("",rand_len,FALSE,0);
  524.  
  525.         if (zeilen_nr)
  526.             plot_int((short) zeile, 4);
  527.         plot_str(TEXT(lauf),(zeilen_nr)?2:0,tab,tab_size);
  528.         plot_nl();
  529.         NEXT(lauf);
  530.         if (IS_TAIL(lauf)) break;
  531.     }
  532.     v_updwk(prn_handle);
  533.     if (vorschub)
  534.         v_clrwk(prn_handle);
  535.     close_printer();
  536.     end_aktion();
  537.     Last_mouse();
  538. }
  539.  
  540. LOCAL VOID drucken(UBYTE *name, RINGP t, BOOLEAN tab, WORD tab_size)
  541. {
  542.     LONG        zeile;
  543.     UBYTE        datum[11], str[40];
  544.     WORD        seite, lzeile;
  545.     LINEP        lauf;
  546.  
  547.     prn_device = ((Setprt(-1)&16) != 0);
  548.  
  549.     if (!prn_check(0))
  550.         return;
  551.  
  552.     if (prn_device == 0)
  553.         strcpy(str, "PRN:");
  554.     else
  555.         strcpy(str, "AUX:");
  556.     if (!WPOpen(str))
  557.         return;
  558.  
  559.     prn_ok = WPSendInit(wp_nlq);
  560.     WPSetTabSize(tab_size);
  561.     prn_ok = WPSetMode(wp_mode);
  562.  
  563.     get_datum(datum);
  564.     lzeile = wp_seiten_len;
  565.     seite = 1;
  566.     zeile = 0;
  567.  
  568.     strcpy(str,STRING(PRINTSTR));
  569.     strcat(str,name);
  570.     start_aktion(str,TRUE,t->lines);
  571.  
  572.     Busy_mouse();
  573.     lauf = FIRST(t);
  574.     while (TRUE)
  575.     {
  576.         if (!prn_check(5))
  577.             break;
  578.  
  579.         if (abbruch())
  580.             if (note(1,BREAK)==1)
  581.                 break;
  582.  
  583.         if (wp_seiten_len && lzeile == wp_seiten_len)
  584.         {
  585.             lzeile = 0;
  586.             if (zeile != 0)
  587.                 plot_ff();
  588.             if (seiten_nr)
  589.             {
  590.                 plot_str(STRING(FILESTR), 7, FALSE, 0); plot_str(name,1,FALSE,0);
  591.                 plot_str(STRING(PAGESTR), 8, FALSE, 0); plot_int(seite++,0);
  592.                 plot_str(STRING(DATESTR), 8, FALSE, 0); plot_str(datum,0,FALSE,0);
  593.                 plot_nl();
  594.                 plot_nl();
  595.                 lzeile = 2;
  596.             }
  597.         }
  598.         do_aktion(zeile);
  599.         zeile++;
  600.         lzeile++;
  601.         if    (use_rand && rand_len > 0)
  602.             plot_str("", rand_len, FALSE, 0);
  603.         if (zeilen_nr)
  604.             plot_int((short) zeile,4);
  605.         plot_str(TEXT(lauf), (zeilen_nr) ? 2 : 0, tab, tab_size);
  606.         plot_nl();
  607.         NEXT(lauf);
  608.         if (IS_TAIL(lauf))
  609.             break;
  610.     }
  611.     if (wp_seiten_len && zeile && vorschub)
  612.         plot_ff();
  613.     WPSendExit();
  614.     WPClose();
  615.     end_aktion();
  616.     Last_mouse();
  617. }
  618. /*****************************************************************************/
  619.  
  620. LOCAL VOID set_font(VOID)        /* trägt Font in die Box ein */
  621. {
  622.     UBYTE    str[32];
  623.  
  624.     if ((strlen(druckFont.Name) == 0) || dev_has_changed)
  625.     {
  626.         strcpy(druckFont.Name, GdosDevices[gdos_device].firstName);
  627.         druckFont.Size = GdosDevices[gdos_device].firstSize;
  628.         druckFont.ID = GdosDevices[gdos_device].firstID;
  629.         dev_has_changed = FALSE;
  630.     }
  631.     itoa(druckFont.Size, str, 10);
  632.     objc_setstring(printer, DSIZE, str);
  633.     objc_setstring(printer, DFONT, druckFont.Name);
  634. }
  635.  
  636. LOCAL VOID set_button(BOOLEAN normal)
  637. {
  638.     disable_objc(printer, DSTART, !normal);
  639.     if (normal)
  640.         do_flags(printer, DSTART, DEFAULT);
  641.     else
  642.         undo_flags(printer, DSTART, DEFAULT);
  643. }
  644.  
  645. LOCAL VOID enable_gdos(VOID)
  646. {
  647.     UBYTE    str[DEV_LEN + 1];
  648.     WORD    i;
  649.  
  650.     top_kartei(printer, DREITER, DGDOSR);
  651.     scanDevices();
  652.     set_button((dev_anzahl > 0));
  653.     if (dev_anzahl == 0)
  654.     {
  655.         objc_setstring(printer, DDEVICE, STRING(NODEVSTR));
  656.         disable_objc(printer, DDEVICE, TRUE);
  657.         disable_objc(printer, DDEVCIRC, TRUE);
  658.         disable_objc(printer, DFONTSEL, TRUE);
  659.         objc_setstring(printer, DFONT, "");
  660.         objc_setstring(printer, DSIZE, "");
  661.     }
  662.     else
  663.     {
  664.         if (gdos_device >= dev_anzahl)        /* aus den Parametern */
  665.         {
  666.             gdos_device = 0;
  667.             dev_has_changed = TRUE;
  668.         }
  669.         open_printer();                            /* aktuelle Fontdaten holen */
  670.         close_printer();
  671.         strcpy(str, " ");
  672.         strcat(str, GdosDevices[gdos_device].devName);
  673.  
  674.         /* Da ersten Eintrag im Popup aufgeblasen ist! */
  675.         if (gdos_device == 0)
  676.             for (i = (WORD)strlen(str); i < DEV_LEN; i++)
  677.                 strcat(str, " ");
  678.  
  679.         objc_setstring(printer, DDEVICE, str);
  680.         set_font();
  681.     }
  682. }
  683.  
  684. LOCAL VOID enable_gemdos(VOID)
  685. {
  686.     UBYTE    tmp[25];
  687.  
  688.     top_kartei(printer, DREITER, DGEMDOSR);
  689.     switch (wp_mode)
  690.     {
  691.         case PICA :
  692.             objc_setstring(printer, DDICHTE, (UBYTE *)get_obspec(popups, DICHTEPICA));
  693.             break;
  694.         case ELITE :
  695.             objc_setstring(printer, DDICHTE, (UBYTE *)get_obspec(popups, DICHTEELITE));
  696.             break;
  697.         case CONDENSED :
  698.             objc_setstring(printer, DDICHTE, (UBYTE *)get_obspec(popups, DICHTECOND));
  699.             break;
  700.     }
  701.     if (!wp_config_read && wp_treiber[0] != EOS)
  702.         WPLoadCFGFile(wp_treiber);
  703.     if (wp_config_read)
  704.         WPGetPrnName(tmp, 25);
  705.     else
  706.         strcpy(tmp, STRING(NODEVSTR));
  707.     set_button(wp_config_read);
  708.     disable_objc(printer, DNLQ, !wp_config_read);
  709.     disable_objc(printer, DDICHTE, !wp_config_read);
  710.     disable_objc(printer, DDICHTCIRC, !wp_config_read);
  711.     select_objc(printer, DNLQ, wp_nlq);
  712.     objc_setstring(printer, DTREIBNAME, tmp);
  713.     itoa(wp_seiten_len, tmp, 10);
  714.     objc_setstring(printer, DLENGTH, tmp);
  715.     itoa(wp_seiten_width, tmp, 10);
  716.     objc_setstring(printer, DWIDTH, tmp);
  717. }
  718.  
  719. VOID build_popup(POPUP_STRUK *pop)
  720. {
  721.     UBYTE    str[DEV_LEN + 1];
  722.     WORD    i;
  723.  
  724.     strcpy(str, " ");
  725.     strcat(str, GdosDevices[0].devName);
  726.     for (i = (WORD)strlen(str); i < DEV_LEN; i++)
  727.         strcat(str, " ");
  728.     create_popup(pop, dev_anzahl, POPUPSTRG, str);
  729.     for (i = 1; i < dev_anzahl; i++)
  730.     {
  731.         strcpy(str, " ");
  732.         strcat(str, GdosDevices[i].devName);
  733.         append_popup(pop, POPUPSTRG, str);
  734.     }
  735.     for(i = 0; i < pop->akt_item + 2; i++)
  736.         xrsrc_obfix(pop->tree, i);
  737.     dial_fix(pop->tree);
  738. }
  739.  
  740. BOOLEAN prn_options(UBYTE *name, BOOLEAN block)
  741. {
  742.     UBYTE            s[14];
  743.     WORD            antw, save_dev, save_mode;
  744.     BOOLEAN        save_gdos_print;
  745.     FONTINFO        save_font;
  746.     DIALINFO        dial;
  747.     POPUP_STRUK    pop;
  748.     WORD            y, edobj;
  749.     PATH            save_treiber;
  750.     FSEL            fsel = {"", "*.CFG"};
  751.     PATH            str = "";
  752.  
  753.     save_gdos_print = use_gdos_print;
  754.     save_dev = gdos_device;
  755.     memcpy(&save_font, &druckFont, sizeof(FONTINFO));
  756.  
  757.     save_mode = wp_mode;
  758.     strcpy(save_treiber, wp_treiber);
  759.  
  760.     /* Allgemeine Parameter */
  761.     select_objc(printer, NUMMERNJ, zeilen_nr);
  762.     select_objc(printer, SEITENJ, seiten_nr);
  763.     select_objc(printer, DVORSCHUB, vorschub);
  764.     select_objc(printer, CHECKPRN, pruef_prn);
  765.     select_objc(printer, DBLOCK, block);
  766.     select_objc(printer, DTEXT, !block);
  767.     disable_objc(printer, DBLOCK, !block);
  768.     select_objc(printer, DRAND, use_rand);
  769.     itoa(rand_len, s, 10);
  770.     objc_setstring(printer, DRANDLEN, s);
  771.  
  772.     /* GDOS überhaupt vorhanden? */
  773.     if (!gdos)
  774.         disable_objc(printer, DGDOSR, TRUE);
  775.  
  776.     if (use_gdos_print && gdos)
  777.         enable_gdos();
  778.     else
  779.         enable_gemdos();
  780.  
  781.     Arrow_mouse();
  782.     open_dial(printer, FALSE, NULL, &dial);
  783.     dial_draw(&dial);
  784.     edobj = DRANDLEN;
  785.     do
  786.     {
  787.         antw = dial_do(&dial, &edobj) & 0x7FFF;
  788.         switch (antw)
  789.         {
  790.             case DGEMDOSR :
  791.                 enable_gemdos();
  792.                 use_gdos_print = FALSE;
  793.                 draw_Objc(printer, DGEMDOSK, MAX_DEPTH);
  794.                 mydraw_obj(NIL, printer, DSTART);
  795.                 break;
  796.             case DGDOSR :
  797.                 enable_gdos();
  798.                 use_gdos_print = TRUE;
  799.                 draw_Objc(printer, DGDOSK, MAX_DEPTH);
  800.                 mydraw_obj(NIL, printer, DSTART);
  801.                 break;
  802.             case DDATEI :
  803.                 if (metafile[0] != EOS)
  804.                 {
  805.                     file_name(metafile, fsel.name, FALSE);
  806.                     set_fsel_path(metafile);
  807.                 }
  808.                 else
  809.                     strcpy(fsel.name, "GEMFILE.GEM");
  810.                 strcpy(fsel.suffix, "*.GEM");
  811.                 close_dial(FALSE, NULL, &dial);
  812.                 if (select_file(&fsel, str, STRING(FINDGDSTR)))
  813.                     strcpy(metafile, str);
  814.                 select_objc(printer, antw, FALSE);
  815.                 open_dial(printer, FALSE, NULL, &dial);
  816.                 dial_draw(&dial);
  817.                 break;
  818.             case DFONTSEL:
  819.                 close_dial(FALSE, NULL, &dial);
  820.                 if (dev_anzahl > 0)
  821.                 {
  822.                     if (open_printer())
  823.                     {
  824.                         if (select_font(prn_handle))
  825.                         {
  826.                             UBYTE    str[32];
  827.  
  828.                             itoa(druckFont.Size, str, 10);
  829.                             objc_setstring(printer, DSIZE, str);
  830.                             objc_setstring(printer, DFONT, druckFont.Name);
  831.                         }
  832.                     }
  833.                     close_printer();
  834.                 }
  835.                 select_objc(printer, antw, FALSE);
  836.                 open_dial(printer, FALSE, NULL, &dial);
  837.                 dial_draw(&dial);
  838.                 break;
  839.             case DDEVSTR :
  840.             case DDEVCIRC:
  841.             case DDEVICE:
  842.                 if (dev_anzahl > 0)
  843.                 {
  844.                     build_popup(&pop);
  845.                     if (antw == DDEVCIRC)
  846.                         y = popup_select(NIL, printer, DDEVICE, pop.tree, 1, FALSE, DO_CYCLE, NULL, (POP_CB)NULL);
  847.                     else
  848.                         y = popup_select(NIL, printer, DDEVICE, pop.tree, 1, FALSE, DO_POPUP, NULL, (POP_CB)NULL);
  849.                     y -= pop.first_item;
  850.                     if (y >= 0)
  851.                     {
  852.                         gdos_device = y;
  853.                         dev_has_changed = TRUE;
  854.                         set_font();
  855.                         draw_Objc(printer, DGDOSK, MAX_DEPTH);
  856.                     }
  857.                     free_popup(&pop);
  858.                 }
  859.                 select_objc(printer, antw, FALSE);
  860.                 draw_Objc(printer, antw, 1);
  861.                 break;
  862.             case DTREIBER :
  863.                 close_dial(FALSE, NULL, &dial);
  864.                 if (wp_treiber[0] != EOS)
  865.                 {
  866.                     file_name(wp_treiber, fsel.name, FALSE);
  867.                     set_fsel_path(wp_treiber);
  868.                 }
  869.                 else
  870.                     strcpy(fsel.name, "");
  871.                 strcpy(fsel.suffix, "*.CFG");
  872.                 if (select_file(&fsel, str, STRING(TREIBERSTR)))
  873.                 {
  874.                     strcpy(wp_treiber, str);
  875.                     wp_config_read = FALSE;
  876.                     if (WPLoadCFGFile(wp_treiber))
  877.                         WPGetPrnName(str, 25);
  878.                     else
  879.                         strcpy(str, STRING(NODEVSTR));
  880.                     objc_setstring(printer, DTREIBNAME, str);
  881.                     set_button(wp_config_read);
  882.                     disable_objc(printer, DNLQ, !wp_config_read);
  883.                     disable_objc(printer, DDICHTE, !wp_config_read);
  884.                     disable_objc(printer, DDICHTCIRC, !wp_config_read);
  885.                 }
  886.                 open_dial(printer, FALSE, NULL, &dial);
  887.                 select_objc(printer, DTREIBER, FALSE);
  888.                 dial_draw(&dial);
  889.                 break;
  890.             case DDICHTESTR :
  891.             case DDICHTCIRC :
  892.             case DDICHTE :
  893.                 if (antw == DDICHTCIRC)
  894.                     y = popup_select(NIL, printer, DDICHTE, popups, DICHTEPOP, FALSE, DO_CYCLE, NULL, (POP_CB)NULL);
  895.                 else
  896.                     y = popup_select(NIL, printer, DDICHTE, popups, DICHTEPOP, FALSE, DO_POPUP, NULL, (POP_CB)NULL);
  897.                 y -= DICHTEPICA;
  898.                 if (y >= 0)
  899.                     wp_mode = y;
  900.                 break;
  901.             default:
  902.                 break;
  903.         }
  904.     }
  905.     while (antw != DOK && antw != DSTART && antw != DRAUS);
  906.     select_objc(printer, antw, FALSE);
  907.     dial_end(&dial);
  908.     Last_mouse();
  909.     if (antw == DRAUS)
  910.     {
  911.         use_gdos_print = save_gdos_print;
  912.         gdos_device = save_dev;
  913.         memcpy(&druckFont, &save_font, sizeof(FONTINFO));
  914.         wp_mode = save_mode;
  915.         strcpy(wp_treiber, save_treiber);
  916.     }
  917.     else
  918.     {
  919.         /* Allgemein */
  920.         zeilen_nr = get_select(printer, NUMMERNJ);
  921.         seiten_nr = get_select(printer, SEITENJ);
  922.         vorschub = get_select(printer, DVORSCHUB);
  923.         pruef_prn = get_select(printer, CHECKPRN);
  924.         print_block = get_select(printer, DBLOCK);
  925.         use_rand = get_select(printer, DRAND);
  926.         objc_getstring(printer, DRANDLEN, s);
  927.         rand_len = atoi(s);
  928.  
  929.         objc_getstring(printer, DLENGTH, s);
  930.         if (*s)
  931.             wp_seiten_len = atoi(s);
  932.         else
  933.             wp_seiten_len = 65;
  934.         objc_getstring(printer, DWIDTH, s);
  935.         if (*s)
  936.             wp_seiten_width = atoi(s);
  937.         else
  938.             wp_seiten_width = 80;
  939.  
  940.         wp_nlq = get_select(printer, DNLQ);
  941.     }
  942.     return (antw == DSTART);
  943. }
  944.  
  945. VOID init_printer(VOID)
  946. {
  947.     gdos_device = 0;
  948.     druckFont.Index = 0;
  949.     druckFont.ID = 0;
  950.     druckFont.Name[0] = EOS;
  951.     druckFont.Size = 10;
  952.     druckFont.Anz = 0;
  953.     dev_has_changed = FALSE;
  954.     printer_type = decl_icon_type(icon_test, icon_edit, icon_exist, icon_drag);
  955. }
  956.